/**
 * Created With IntelliJ IDEA
 * Description:
 * User: DELL
 * Data: 2023-03-18
 * Time: 23:27
 */
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回表达式的值
     * @param s string字符串 待计算的表达式
     * @return int整型
     */
    public int solve (String s) {
        // write code here
        //初始化栈
        Stack<Integer> stack = new Stack<>();
        //结果
        int sum = 0;
        //默认数字，运算符
        int number = 0;
        //默认的第一个数字前的运算符为 +
        char sign = '+';

        //字符串转化字符数组
        char[] arr = s.toCharArray();
        int n = s.length();

        //对字符数组每个元素遍历
        for(int i = 0;i<n;i++){

            char c = arr[i];
            //是否为左括号
            if(c == '('){
                int j = i + 1;
                //默认是1对括号
                int counterPar = 1;
                while(counterPar > 0){
                    //统计是否存在括号嵌套的情况
                    if(arr[j] == '('){
                        counterPar++;
                    }
                    if(arr[j] == ')'){
                        counterPar--;
                    }
                    //向后直到找到右括号
                    j++;
                }
                //遇到左括号递归求这个括号里面表达式的值
                //就是求左括号 到 右括号 之间 表达式的 值,返回值为 number,下面接着进栈
                number  = solve(s.substring(i + 1,j - 1));
                //下一次就要从 j 开始，因为后面还有一个 i ++;
                i = j - 1;


            }
            //是否为数字，是数字就求完整的数字值，每次循环都进这个分支，直到出现运算符
            if(Character.isDigit(c)){
                number = number * 10 + c - '0';
            }
            //不是数字 或者 为最后一个字符
            if( ! Character.isDigit(c) || i == n - 1){

                if(sign == '+'){
                    //是 + 先把 数字 压栈，等会全部数字出栈之和即为所求
                    stack.push(number);
                }
                else if(sign == '-'){
                    //是 - 压栈该数字的相反数
                    stack.push( -1 * number);
                }
                else if(sign == '*'){
                    //是 * ，弹栈算出结果，在压栈
                    stack.push(stack.pop() * number);
                }
                else if(sign == '/'){
                    //是 / ，弹栈算出结果，在压栈
                    stack.push(stack.pop() / number);
                }
                //每次结束，数字恢复默认值
                number = 0;
                // 遇到运算符时或者到表达式末尾时，就去计算上一个运算符并把计算结果push进栈，然后保存新的运算符
                //运算符为 当前压栈数字 前面近邻的那个
                sign = c;

                //如果是负数 在 表达式的最前面 ，会先压栈 +0，然后在记录当前 负号，开始接下来的数字
            }
        }
        while(!stack.isEmpty()){
            sum += stack.pop();
        }
        return sum;

    }
}

